geany-std.cpp.tags
==================

Geany `.tags` file for the 
Standard Templated Containers, Generic Algorithms, Functional Programming and Miscellaneous Utilities Framework for the Development of C-Plus-Plus Programs.

The what?
---------

The _Standard Templated Containers, Generic Algorithms, Functional Programming and Miscellaneous Utilities Framework for the Development of C-Plus-Plus Programs_. 

...Perhaps some explaining is in order.

There is a large set of utilities provided by the C++ Standard. These go from generic algorithms such as `copy` and `find`, to generic-use containers such as `vector` and `list`, to functionoid binders for purposes of functional programming such as `bind` and `cref`, and beyond.

Over time, there have been internet wars over [what to call this set of standard utilities](http://stackoverflow.com/questions/5205491/whats-this-stl-vs-c-standard-library-fight-all-about). 
Some people call them the "stdlib", some other people call them the "STL", with a defined meaning, and some other people _also_ call them the "STL" but refer to a basis provided by SGI, and yet some other people talk about the "Standard STL" (more or less in the same vein as the ATM Machines in which you insert a PIN Number).

There was a small, in-joke contest in the Freenode `#C++` Channel (link to be provided) 
to produce the longest, unambiguous term to refer to this set of utilities, 
during which I came up with the acronym `STCGAFPMUFDCPPP`, which I've adopted in all my code and documentation ever since (but I don't have much hope of it ever catching up).

As such, when I decided to create a tags file for this set of utilities, of course I ended up using this name for them.


Why?
----

Because Geany lacks one, and coming up with a sensible one is hard to do, and having a handy reference of the features the C++ Standard provides is always good, considering the language is evolving with a new Standard being released in 2011, another one in 2014 and then another one in 2017.


How?
----

Just like any other `.tags` file for Geany. 

Just copy this into your config directory's `tags` subdirectory.


When?
-----

Like, right now. Just clone the repo (or extract this same tags file from the 
official Geany Wiki).



What is included?
-----------------

Function signatures of a number of template utilities, algorithms, etc., are provided. Because Geany lacks tag completion support from `<`, constructors for features such as Standard containers can not be provided currently; they are included in the file only for completeness.

Several public function interfaces from the following C++ headers are provided in the tags file:

* `<algorithm>` - generic algorithms to `copy` sequences, `find` elements, perform transformations, `sort`, `search`, etc.
* `<functional>` - reference wrappers, `function` object and functionoid binders such as `mem_fn`, etc.
* `<ios>`, `<iostream>` and `<iomanip>` - the various stream state functions.
* `<iterator>` - the iterator helper conveniences such as `next` and `prev`, as well as the upcoming C++14 and C++17 additions such as "global" `size` and `data`.
* `<memory>` - the `make_shared`, `make_unique` conveniences and various memory management related utilities.
* `<numeric>` - the numeric utilities starting with C++11's `iota`.
* `<system_error>` - the functions used to tag error code and error category elements.
* `<tuple>` - the `make_tuple` convenience and other tuple-related functions.
* `<utility>` - the standard utilities such as `swap`, `move`, as well as some later additions.
* Iterator constructors for the vector, list, forward_list and deque containers.

Changes in the latest version:
------------------------------

* Added the `for_each_n`, `clamp` and shift (left, right) algorithms from C++17 and C++20.
* Added the new `lexicographical_compare_three_way`.
* Added the global container-to-iterator accessors in C++17 ( `size`, `data` and `empty`).
* Added `as_const`, `in_range` from `<utility>`.
* Fixed the overloads for `make_unique`.

What is missing in the latest version?
--------------------------------------

* All the heap algorithms.
* All the partition algorithms.
* All templated object constructs (Geany only provides tag completion opening on `(`, not on `<`).
* Consequently, most of everything in `<type_traits>`.
* Consequently, most of everything in `<random>`.
* The new C++11 functions from `<cmath>` and other related headers.
* Everything related to the garbage collection features.
* Everything related to thread support.
* Everything related to _Execution Policy_.
* Everything related to `<regex>` (from C++11).
* Everything related to `<optional>` (from C++ C++17).
* Everything related to `<variant>` (from C++17).
* Everything related to `<any>` (from C++17).
* Everything related to `<numbers>` (from C++20).


I don't have some of those functions?
-------------------------------------

''You might not have `#include`d the necessary header''.

Consult a C++ reference to determine what header you need to include to have 
access to these features. 

''Your compiler might not have access to the C++ Standard required for those feayures''.

In the general sense, it's most likely you are using a compiler with an old (or new) enough C++ Standard that some of these features are not available or have changed in form, for example:

* You might be using C++98/03, where some of the algorithms are not provided.
* You might be using C++98/03, where only the `next` and `prev` iterator utilities are provided.
* You might be using C++98/03, where rvalue-references and `unique_ptr` features are not provided.
* You might be using C++98/03, where anything using _variadic argument lists_ is not provided.
* You might be using C++98/03, where `<system_error>` is not provided.
* You might be using C++11 or later, which deprecates or removes `auto_ptr`.
* You might be using C++11, where some functions in `<algorithm>` changed their return types from C++03.
* You might be using C++ previous to C++14, so some functions in `<algorithm>` are missing overloads.
* You might be using C++ previous to C++17, so headers such as `<any>` or `<optional>` are not provided.
* You may be using C++17 or C++20, where a number of elements in `<type_traits>` are deprecated or removed.
* You might be using C++20, where a number of elements in `<functional>` are deprecated or removed.

Check your compiler and STL's documentation for information on what features you do actually have available.

If the case is that you are missing out on some features, you can still get *some* of them by adding to your environment / project a framework or toolkit library that provides a compatibility access layer for later C++ Standards. Examples include 
 _[cxxomfort](http://ryan.gulix.cl/fossil.cgi/cxxomfort)_ or _Boost_.

